package commons.utils;

import commons.logs.Logger;
import java.awt.Color;
import java.awt.GraphicsEnvironment;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.Random;
import java.util.regex.PatternSyntaxException;
import javax.swing.JOptionPane;

public class Utils {


	public enum Side {RIGHT, LEFT};
	
	// Utilisé pour alimenter les combo des tableaux de paramétrage
	public static ArrayList<String> getVValeurPossibleSidePlusVide() {
		ArrayList<String> v = new ArrayList<String>();
		v.add("");
		v.add(Side.RIGHT.toString());
		v.add(Side.LEFT.toString());
		return v;
	}
	
	public enum SeparateurDecimal {VIRGULE, POINT, INCONNU};

	static Random rnd_;

	static SimpleDateFormat dateFormat1;
	static SimpleDateFormat dateFormat2;
	
	static {
		rnd_=new Random(12345);

		dateFormat1 = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
		dateFormat2 = new SimpleDateFormat("dd/MM/yyyy");
	}

	public static double rnd() {
		return rnd_.nextDouble();
	}

	public static SeparateurDecimal getCurrentJavaSeparateurDecimal() {
		String s = "123.45";
		try {
			Double.parseDouble(s);
			return SeparateurDecimal.POINT;
		}
		catch (NumberFormatException ex1) {

			s = "123,45";
			try {
				Double.parseDouble(s);
				return SeparateurDecimal.VIRGULE;
			}
			catch (NumberFormatException ex2) {
				Logger.log_ERROR("!! IMPOSSIBLE DE DETERMINER LE SEPARATEUR DECIMAL !!!");
				ex2.printStackTrace();
				return SeparateurDecimal.INCONNU;
			}
		}
	}

	// APartir d'une couleur en entrée, renvoie une couleur grisée et eclaircie
	public static Color getColorGrisee(Color col) {
		double red = col.getRed();
		double green = col.getGreen();
		double blue = col.getBlue();

		double FACTOR = 0.8;
		if (red>128)
			red = Math.max(red - (red-128)*FACTOR, 128);
		else
			red = Math.min(red + (128-red)*FACTOR, 128);

		if (green>128)
			green = Math.max(green - (green-128)*FACTOR, 128);
		else
			green = Math.min(green + (128-green)*FACTOR, 128);

		if (blue>128)
			blue = Math.max(blue - (blue-128)*FACTOR, 128);
		else
			blue = Math.min(blue + (128-blue)*FACTOR, 128);

		return new Color ((int)red, (int)green, (int)blue).brighter();
	}

	public static Color getBestTextColor(Color colFond) {
		double red = colFond.getRed();
		double green = colFond.getGreen();
		double blue = colFond.getBlue();
		if ((red+green+blue)/3 > 128)
			return Color.black;
		else
			return Color.white;
	}
	

	public static boolean isInteger (String possibleInt) {
		try {
			Integer.parseInt(possibleInt);
		} catch (Exception e) {
			return false;
		}
		return true;
	}

	public static boolean isInteger_Pos (String possibleInt) {
		try {
			int i = Integer.parseInt(possibleInt);
			return i>=0;
		} catch (Exception e) {
			return false;
		}
	}

	public static boolean isInteger_strictPos (String possibleInt) {
		try {
			int i = Integer.parseInt(possibleInt);
			return i>0;
		} catch (Exception e) {
			return false;
		}
	}

	public static boolean isFloat (String possibleFloat) {
		try {
			Double.parseDouble(possibleFloat);
		} catch (Exception e) {
			return false;
		}
		return true;
	}
	public static boolean isFloat_Pos (String possibleFloat) {
		try {
			double d = Double.parseDouble(possibleFloat);
			return d>=0.0;
		} catch (Exception e) {
			return false;
		}
	}
	public static boolean isFloat_strictPos (String possibleFloat) {
		try {
			double d = Double.parseDouble(possibleFloat);
			return d>0.0;
		} catch (Exception e) {
			return false;
		}
	}

	public static boolean isDate (String possibleDate) {
		try {
			dateFormat1.parse(possibleDate);
			return true;
		} catch (Exception e) {
			try {
			dateFormat2.parse(possibleDate);
			return true;
			} catch (Exception e2) {

				//System.out.println("######## PAS UNE DATE : " + possibleDate + " ##########");
				return false;
			}
		}
	}
	public static Date parseDate (String possibleDate) {
		try {
			return dateFormat1.parse(possibleDate);
		} catch (Exception e) {

			try {
				return dateFormat2.parse(possibleDate);
			} catch (Exception e2) {
				//System.out.println("######## PAS UNE DATE : " + possibleDate + " ##########");
				return null;
			}			
		}
	}

	public static boolean isValidePattern (String pattern) {
		try {
			"Test".matches(pattern);
		} catch (PatternSyntaxException e) {
			System.out.println(e.getMessage());
			return false;
		}
		return true;
	}

	// Implémente une fonction absente dans ArrayList mais présente dans Vector
    public static int indexOf(ArrayList v, Object o, int index) {
		if (o == null) {
			for (int i = index ; i < v.size() ; i++)
				if (v.get(i)==null)
					return i;
		} else {
			for (int i = index ; i < v.size(); i++)
				if (o.equals(v.get(i)))
					return i;
		}
		return -1;
	}


	// Split un peu plus rapide que celui de Java et qui ne buggue pas
	//  si les attributs sont vide entre les derniers separator
	// Aucun des element du resultat n'est null ("" à la place)
	public static String[] mySplit(String s, char separator) {

		char[] s_char = s.toCharArray();
		int size = s.length();

		// 1ere passe pour savoir la taille du tableau resultat
		int nbSeparator = 0;
		for (int i=0 ; i<size ; i++) {
			if (s_char[i] == separator)
				nbSeparator++;
		}

		String[] res = new String[nbSeparator+1];

		int index_Res = 0;
		int index_lastStop = 0;
		int index_Current = 0;

		while (true) {

			if (index_Current>=size)
				break;
			
			if (s_char[index_Current] == separator) {
				// extraction de la sous-chaine trouvée
				res[index_Res] = s.substring(index_lastStop, index_Current);
				index_Res++;
				index_Current++;
				index_lastStop = index_Current;
			} else
				index_Current++;

		}

		//derniere chaine a extraire
		if (s_char[size-1]==separator)
			res[index_Res] = "";
		else
			res[index_Res] = s.substring(index_lastStop, index_Current);

		// petite optimisation mémoire
		for (int i = 0; i<res.length; i++) {
			res[i] = res[i].intern();
		}
		
		return res;
	}

	private static ArrayList<String> listFamilyName = null;
	public static ArrayList<String> getInstalledFontFamily() {
		if (listFamilyName == null) {
			GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
			String[] list = ge.getAvailableFontFamilyNames();
			Arrays.sort(list);
			listFamilyName = new ArrayList<String>();
			for (String s : list)
				listFamilyName.add(s);
		}
		return listFamilyName;
	}
}
